Implement applied constructor types #22543

KacperFKorban · 2025-02-06T12:59:24Z

Introduce new syntax to make classes with tracked parameters
easier to use. The new syntax is essentially the ability to use an application
of a class constructor as a type, we call such types applied constructor types.

With this new feature the following example compiles correctly and the type in
the comment is the resulting type of the applied constructor types.

import scala.language.experimental.modularity

class C(tracked val v: Any)

val c: C(42) /* C { val v: 42 } */ = C(42)

Syntax change

SimpleType        ::=  SimpleLiteral
                    |  ‘?’ TypeBounds
---                 |  SimpleType1
+++                 |  SimpleType1 {ParArgumentExprs}

A SimpleType can now optionally be followed by ParArgumentExprs.

docs/_docs/reference/experimental/modularity.md

tests/neg/applied_constructor_types.scala

KacperFKorban · 2025-02-10T11:44:46Z

The CI failure seems to be the same as on main and looks unrelated.

Co-authored-by: Kacper Korban <[email protected]>

- only type applied constructor types in Typer - handle multiple parameter lists - add tests for mixed tracked and not tracked parameters

examples; Hide more implementation parts under modularity

mbovel · 2025-02-11T14:05:02Z

I've noticed during your presentation that it also works for using parameters:

import language.experimental.modularity

class Box[T](using tracked val value: Int)

def main =
  given Int = 42
  val b: Box() = Box()

after typer:

def main: Unit =
  final lazy given val given_Int: Int = 42
  val b: Box[Any]{val value: (given_Int : Int)} = new Box[Any](given_Int)()

…r types

odersky · 2025-04-07T08:33:07Z

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2018,7 +2008,7 @@ object Parsers {
    /**  SimpleType      ::=  SimpleLiteral
     *                     |  ‘?’ TypeBounds
     *                     |  SimpleType1
-     *                     |  SimpleType ‘(’ Singletons ‘)’  -- under language.experimental.dependent, checked in Typer
+     *                     |  SimpleType ‘(’ Singletons ‘)’  -- under language.experimental.modularity, checked in Typer


checked in Typer is no longer correct, we do check the feature flag here.

odersky · 2025-04-07T08:35:07Z

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1694,6 +1694,23 @@ trait Applications extends Compatibility {
  def typedUnApply(tree: untpd.UnApply, selType: Type)(using Context): UnApply =
    throw new UnsupportedOperationException("cannot type check an UnApply node")

+  def typedAppliedConstructorType(tree: untpd.Apply)(using Context) = untpd.methPart(tree) match
+      case Select(New(tpt), _) =>


why 4 spaces of indent here?

odersky · 2025-04-07T08:35:57Z

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1694,6 +1694,23 @@ trait Applications extends Compatibility {
  def typedUnApply(tree: untpd.UnApply, selType: Type)(using Context): UnApply =
    throw new UnsupportedOperationException("cannot type check an UnApply node")

+  def typedAppliedConstructorType(tree: untpd.Apply)(using Context) = untpd.methPart(tree) match


Should add a doc comment explaining what kind of expressions this typechecks.

odersky · 2025-04-07T08:39:52Z

compiler/src/dotty/tools/dotc/typer/Applications.scala

+  def typedAppliedConstructorType(tree: untpd.Apply)(using Context) = untpd.methPart(tree) match
+      case Select(New(tpt), _) =>
+        val tree1 = typedExpr(tree)
+        val widenSkolemsMap = new TypeMap:


widenSkolemsMap is defined in the same way in NamerOps. I suggest we move the whole thing to TypeUtils, into an extension method widenSkolems and refer to that from both places.

odersky · 2025-04-07T08:42:23Z

compiler/src/dotty/tools/dotc/typer/Applications.scala

+        val preciseTp = widenSkolemsMap(tree1.tpe)
+        val classTp = typedType(tpt).tpe
+        def classSymbolHasOnlyTrackedParameters =
+          classTp.classSymbol.primaryConstructor.paramSymss.flatten.filter(_.isTerm).forall(_.is(Tracked))


Suggested change

classTp.classSymbol.primaryConstructor.paramSymss.flatten.filter(_.isTerm).forall(_.is(Tracked))

!classTp.classSymbol.primaryConstructor.paramSymss.nestedExists: param =>

param.isTerm && !param.is(Tracked)

This avoids the costly flatten.

odersky · 2025-04-07T08:50:46Z

compiler/src/dotty/tools/dotc/typer/Applications.scala

+          classTp.classSymbol.primaryConstructor.paramSymss.flatten.filter(_.isTerm).forall(_.is(Tracked))
+        if !preciseTp.isError && !classSymbolHasOnlyTrackedParameters then
+          report.warning(OnlyFullyDependentAppliedConstructorType(), tree.srcPos)
+        if !preciseTp.isError && (preciseTp frozen_=:= classTp) then


I did not understand the condition. I guess you want to exclude constructors with no value parameters, but I am not clear why the condition preciseTp frozen_=:= classTp is equivalent to that.

odersky · 2025-04-07T08:55:53Z

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -3485,7 +3477,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer

  /** Typecheck tree without adapting it, returning a typed tree.
   *  @param initTree    the untyped tree
-   *  @param pt          the expected result type
+   *  @param pt          the expected result typ


odersky · 2025-04-07T08:59:58Z

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -3525,7 +3517,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer

        def typedUnnamed(tree: untpd.Tree): Tree = tree match {
          case tree: untpd.Apply =>
-            if (ctx.mode is Mode.Pattern) typedUnApply(tree, pt) else typedApply(tree, pt)
+            if (ctx.mode is Mode.Pattern) typedUnApply(tree, pt)
+            else if (Feature.enabled(modularity) && ctx.mode.is(Mode.Type) && !ctx.isAfterTyper) typedAppliedConstructorType(tree)


The new case should not be added here. This is about the hottest code that exists in the compiler. We need to keep it as small as possible. Instead I would suggest to add the distinction to Applications.scala following line 1283:

val app = tree.fun match case Select(New(tpt), _) if ctx.mode.is(Mode.Type) && Feature.enabled(modularity && !ctx.isAfterTyper => typedAppliedConstructorType(tpt, tree.args) case untpd.TypeApply(_: untpd.SplicePattern, _) if Feature.quotedPatternsWithPolymorphicFunctionsEnabled => ...

odersky · 2025-04-07T09:03:36Z

compiler/src/dotty/tools/dotc/typer/Applications.scala

+          report.warning(PointlessAppliedConstructorType(tpt, tree.args, classTp), tree.srcPos)
+        TypeTree(preciseTp)
+      case _ =>
+        throw TypeError(em"Unexpected applied constructor type: $tree")


Can this ever happen for a parsed program? If not we should throw an assertion instead of a TypeError. But with the refactoring proposed in Typer, we can avoid the pattern match here and hence the error case would be eliminated.

odersky · 2025-04-07T09:24:33Z

docs/_docs/reference/experimental/modularity.md

+++                 |  SimpleType1 {ParArgumentExprs}
+```
+
+A `SimpleType` can now optionally be followed by `ParArgumentExprs`.


Maybe add some explanations how argument expressions map to refinements.

bishabosha reviewed Feb 6, 2025

View reviewed changes

docs/_docs/reference/experimental/modularity.md Outdated Show resolved Hide resolved

tests/neg/applied_constructor_types.scala Show resolved Hide resolved

KacperFKorban added the release-notes Should be mentioned in the release notes label Feb 7, 2025

KacperFKorban force-pushed the mb/applied-constructors branch from a12b589 to f64cc82 Compare February 7, 2025 17:16

KacperFKorban marked this pull request as ready for review February 10, 2025 11:43

KacperFKorban requested a review from odersky February 10, 2025 11:43

KacperFKorban assigned odersky Feb 10, 2025

mbovel and others added 14 commits February 11, 2025 09:12

Add support for applied constructor sugar

09aa88d

Move applied constructor types under modularity

50a8347

Support nested constructor applications as types

4ef6ac2

Extract applied constructors logic to a separate function

ad9d163

Fix desugaring explicitly applied generics

26908e2

Some more applied constructor tests

4848e07

Parse applied constructor type arguments as trees

ab7d45a

Co-authored-by: Kacper Korban <[email protected]>

Update check file for applied constructor types neg test

2b884f5

Extract a tracked related bug to a separate issue: scala#22540

21888c6

Add a warning message for a pointless applied constructor type use

a119e08

Add docs and syntax change for applied constructor types

e68753a

Prevent crashes in erroneous cases

69ff014

More applied constructor types fixes

a23b628

- only type applied constructor types in Typer - handle multiple parameter lists - add tests for mixed tracked and not tracked parameters

Ignore best effort compilation failure; add some more controversial

64aee9d

examples; Hide more implementation parts under modularity

KacperFKorban force-pushed the mb/applied-constructors branch from 51894ab to 64aee9d Compare February 11, 2025 08:12

Warn when a non-fully-dependent class is used with applied constructo…

838a3bc

…r types

odersky requested changes Apr 7, 2025

View reviewed changes

odersky assigned KacperFKorban and unassigned odersky Apr 7, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Implement applied constructor types #22543

Implement applied constructor types #22543

KacperFKorban commented Feb 6, 2025 •

edited

Loading

KacperFKorban commented Feb 10, 2025

mbovel commented Feb 11, 2025 •

edited

Loading

odersky Apr 7, 2025

odersky Apr 7, 2025

odersky Apr 7, 2025

odersky Apr 7, 2025

odersky Apr 7, 2025

odersky Apr 7, 2025

odersky Apr 7, 2025

odersky Apr 7, 2025

odersky Apr 7, 2025

odersky Apr 7, 2025

	classTp.classSymbol.primaryConstructor.paramSymss.flatten.filter(_.isTerm).forall(_.is(Tracked))
	!classTp.classSymbol.primaryConstructor.paramSymss.nestedExists: param =>
	param.isTerm && !param.is(Tracked)

Implement applied constructor types #22543

Are you sure you want to change the base?

Implement applied constructor types #22543

Conversation

KacperFKorban commented Feb 6, 2025 • edited Loading

Syntax change

KacperFKorban commented Feb 10, 2025

mbovel commented Feb 11, 2025 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

KacperFKorban commented Feb 6, 2025 •

edited

Loading

mbovel commented Feb 11, 2025 •

edited

Loading